home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Freeware / Adobe Air 1.5 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / containers / utilityClasses / CanvasLayout.as < prev    next >
Encoding:
Text File  |  2008-10-29  |  53.6 KB  |  1,659 lines
  1. package mx.containers.utilityClasses
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.geom.Rectangle;
  5.    import flash.utils.Dictionary;
  6.    import mx.containers.errors.ConstraintError;
  7.    import mx.core.Container;
  8.    import mx.core.EdgeMetrics;
  9.    import mx.core.FlexVersion;
  10.    import mx.core.IConstraintClient;
  11.    import mx.core.IUIComponent;
  12.    import mx.core.mx_internal;
  13.    import mx.events.ChildExistenceChangedEvent;
  14.    import mx.events.MoveEvent;
  15.    
  16.    use namespace mx_internal;
  17.    
  18.    public class CanvasLayout extends Layout
  19.    {
  20.       mx_internal static const VERSION:String = "3.0.0.0";
  21.       
  22.       private static var r:Rectangle = new Rectangle();
  23.       
  24.       private var colSpanChildren:Array;
  25.       
  26.       private var constraintRegionsInUse:Boolean = false;
  27.       
  28.       private var rowSpanChildren:Array;
  29.       
  30.       private var constraintCache:Dictionary;
  31.       
  32.       private var _contentArea:Rectangle;
  33.       
  34.       public function CanvasLayout()
  35.       {
  36.          colSpanChildren = [];
  37.          rowSpanChildren = [];
  38.          constraintCache = new Dictionary(true);
  39.          super();
  40.       }
  41.       
  42.       private function parseConstraints(param1:IUIComponent = null) : ChildConstraintInfo
  43.       {
  44.          var _loc3_:Number = NaN;
  45.          var _loc4_:Number = NaN;
  46.          var _loc5_:Number = NaN;
  47.          var _loc6_:Number = NaN;
  48.          var _loc7_:Number = NaN;
  49.          var _loc8_:Number = NaN;
  50.          var _loc9_:Number = NaN;
  51.          var _loc10_:String = null;
  52.          var _loc11_:String = null;
  53.          var _loc12_:String = null;
  54.          var _loc13_:String = null;
  55.          var _loc14_:String = null;
  56.          var _loc15_:String = null;
  57.          var _loc16_:String = null;
  58.          var _loc17_:Array = null;
  59.          var _loc18_:int = 0;
  60.          var _loc30_:ConstraintColumn = null;
  61.          var _loc31_:Boolean = false;
  62.          var _loc32_:ConstraintRow = null;
  63.          var _loc2_:LayoutConstraints = getLayoutConstraints(param1);
  64.          if(!_loc2_)
  65.          {
  66.             return null;
  67.          }
  68.          _loc17_ = parseConstraintExp(_loc2_.left);
  69.          if(!_loc17_)
  70.          {
  71.             _loc3_ = NaN;
  72.          }
  73.          else if(_loc17_.length == 1)
  74.          {
  75.             _loc3_ = Number(_loc17_[0]);
  76.          }
  77.          else
  78.          {
  79.             _loc10_ = _loc17_[0];
  80.             _loc3_ = Number(_loc17_[1]);
  81.          }
  82.          _loc17_ = parseConstraintExp(_loc2_.right);
  83.          if(!_loc17_)
  84.          {
  85.             _loc4_ = NaN;
  86.          }
  87.          else if(_loc17_.length == 1)
  88.          {
  89.             _loc4_ = Number(_loc17_[0]);
  90.          }
  91.          else
  92.          {
  93.             _loc11_ = _loc17_[0];
  94.             _loc4_ = Number(_loc17_[1]);
  95.          }
  96.          _loc17_ = parseConstraintExp(_loc2_.horizontalCenter);
  97.          if(!_loc17_)
  98.          {
  99.             _loc5_ = NaN;
  100.          }
  101.          else if(_loc17_.length == 1)
  102.          {
  103.             _loc5_ = Number(_loc17_[0]);
  104.          }
  105.          else
  106.          {
  107.             _loc12_ = _loc17_[0];
  108.             _loc5_ = Number(_loc17_[1]);
  109.          }
  110.          _loc17_ = parseConstraintExp(_loc2_.top);
  111.          if(!_loc17_)
  112.          {
  113.             _loc6_ = NaN;
  114.          }
  115.          else if(_loc17_.length == 1)
  116.          {
  117.             _loc6_ = Number(_loc17_[0]);
  118.          }
  119.          else
  120.          {
  121.             _loc13_ = _loc17_[0];
  122.             _loc6_ = Number(_loc17_[1]);
  123.          }
  124.          _loc17_ = parseConstraintExp(_loc2_.bottom);
  125.          if(!_loc17_)
  126.          {
  127.             _loc7_ = NaN;
  128.          }
  129.          else if(_loc17_.length == 1)
  130.          {
  131.             _loc7_ = Number(_loc17_[0]);
  132.          }
  133.          else
  134.          {
  135.             _loc14_ = _loc17_[0];
  136.             _loc7_ = Number(_loc17_[1]);
  137.          }
  138.          _loc17_ = parseConstraintExp(_loc2_.verticalCenter);
  139.          if(!_loc17_)
  140.          {
  141.             _loc8_ = NaN;
  142.          }
  143.          else if(_loc17_.length == 1)
  144.          {
  145.             _loc8_ = Number(_loc17_[0]);
  146.          }
  147.          else
  148.          {
  149.             _loc15_ = _loc17_[0];
  150.             _loc8_ = Number(_loc17_[1]);
  151.          }
  152.          _loc17_ = parseConstraintExp(_loc2_.baseline);
  153.          if(!_loc17_)
  154.          {
  155.             _loc9_ = NaN;
  156.          }
  157.          else if(_loc17_.length == 1)
  158.          {
  159.             _loc9_ = Number(_loc17_[0]);
  160.          }
  161.          else
  162.          {
  163.             _loc16_ = _loc17_[0];
  164.             _loc9_ = Number(_loc17_[1]);
  165.          }
  166.          var _loc19_:ContentColumnChild = new ContentColumnChild();
  167.          var _loc20_:Boolean = false;
  168.          var _loc21_:Number = 0;
  169.          var _loc22_:Number = 0;
  170.          var _loc23_:Number = 0;
  171.          _loc18_ = 0;
  172.          while(_loc18_ < IConstraintLayout(target).constraintColumns.length)
  173.          {
  174.             _loc30_ = IConstraintLayout(target).constraintColumns[_loc18_];
  175.             if(_loc30_.mx_internal::contentSize)
  176.             {
  177.                if(_loc30_.id == _loc10_)
  178.                {
  179.                   _loc19_.leftCol = _loc30_;
  180.                   _loc19_.leftOffset = _loc3_;
  181.                   _loc19_.left = _loc21_ = _loc18_;
  182.                   _loc20_ = true;
  183.                }
  184.                if(_loc30_.id == _loc11_)
  185.                {
  186.                   _loc19_.rightCol = _loc30_;
  187.                   _loc19_.rightOffset = _loc4_;
  188.                   _loc19_.right = _loc22_ = _loc18_ + 1;
  189.                   _loc20_ = true;
  190.                }
  191.                if(_loc30_.id == _loc12_)
  192.                {
  193.                   _loc19_.hcCol = _loc30_;
  194.                   _loc19_.hcOffset = _loc5_;
  195.                   _loc19_.hc = _loc23_ = _loc18_ + 1;
  196.                   _loc20_ = true;
  197.                }
  198.             }
  199.             _loc18_++;
  200.          }
  201.          if(_loc20_)
  202.          {
  203.             _loc19_.child = param1;
  204.             if(_loc19_.leftCol && !_loc19_.rightCol || _loc19_.rightCol && !_loc19_.leftCol || Boolean(_loc19_.hcCol))
  205.             {
  206.                _loc19_.span = 1;
  207.             }
  208.             else
  209.             {
  210.                _loc19_.span = _loc22_ - _loc21_;
  211.             }
  212.             _loc31_ = false;
  213.             _loc18_ = 0;
  214.             while(_loc18_ < colSpanChildren.length)
  215.             {
  216.                if(_loc19_.child == colSpanChildren[_loc18_].child)
  217.                {
  218.                   _loc31_ = true;
  219.                   break;
  220.                }
  221.                _loc18_++;
  222.             }
  223.             if(!_loc31_)
  224.             {
  225.                colSpanChildren.push(_loc19_);
  226.             }
  227.          }
  228.          _loc20_ = false;
  229.          var _loc24_:ContentRowChild = new ContentRowChild();
  230.          var _loc25_:Number = 0;
  231.          var _loc26_:Number = 0;
  232.          var _loc27_:Number = 0;
  233.          var _loc28_:Number = 0;
  234.          _loc18_ = 0;
  235.          while(_loc18_ < IConstraintLayout(target).constraintRows.length)
  236.          {
  237.             _loc32_ = IConstraintLayout(target).constraintRows[_loc18_];
  238.             if(_loc32_.mx_internal::contentSize)
  239.             {
  240.                if(_loc32_.id == _loc13_)
  241.                {
  242.                   _loc24_.topRow = _loc32_;
  243.                   _loc24_.topOffset = _loc6_;
  244.                   _loc24_.top = _loc25_ = _loc18_;
  245.                   _loc20_ = true;
  246.                }
  247.                if(_loc32_.id == _loc14_)
  248.                {
  249.                   _loc24_.bottomRow = _loc32_;
  250.                   _loc24_.bottomOffset = _loc7_;
  251.                   _loc24_.bottom = _loc26_ = _loc18_ + 1;
  252.                   _loc20_ = true;
  253.                }
  254.                if(_loc32_.id == _loc15_)
  255.                {
  256.                   _loc24_.vcRow = _loc32_;
  257.                   _loc24_.vcOffset = _loc8_;
  258.                   _loc24_.vc = _loc27_ = _loc18_ + 1;
  259.                   _loc20_ = true;
  260.                }
  261.                if(_loc32_.id == _loc16_)
  262.                {
  263.                   _loc24_.baselineRow = _loc32_;
  264.                   _loc24_.baselineOffset = _loc9_;
  265.                   _loc24_.baseline = _loc28_ = _loc18_ + 1;
  266.                   _loc20_ = true;
  267.                }
  268.             }
  269.             _loc18_++;
  270.          }
  271.          if(_loc20_)
  272.          {
  273.             _loc24_.child = param1;
  274.             if(_loc24_.topRow && !_loc24_.bottomRow || _loc24_.bottomRow && !_loc24_.topRow || _loc24_.vcRow || Boolean(_loc24_.baselineRow))
  275.             {
  276.                _loc24_.span = 1;
  277.             }
  278.             else
  279.             {
  280.                _loc24_.span = _loc26_ - _loc25_;
  281.             }
  282.             _loc31_ = false;
  283.             _loc18_ = 0;
  284.             while(_loc18_ < rowSpanChildren.length)
  285.             {
  286.                if(_loc24_.child == rowSpanChildren[_loc18_].child)
  287.                {
  288.                   _loc31_ = true;
  289.                   break;
  290.                }
  291.                _loc18_++;
  292.             }
  293.             if(!_loc31_)
  294.             {
  295.                rowSpanChildren.push(_loc24_);
  296.             }
  297.          }
  298.          var _loc29_:ChildConstraintInfo = new ChildConstraintInfo(_loc3_,_loc4_,_loc5_,_loc6_,_loc7_,_loc8_,_loc9_,_loc10_,_loc11_,_loc12_,_loc13_,_loc14_,_loc15_,_loc16_);
  299.          constraintCache[param1] = _loc29_;
  300.          return _loc29_;
  301.       }
  302.       
  303.       private function bound(param1:Number, param2:Number, param3:Number) : Number
  304.       {
  305.          if(param1 < param2)
  306.          {
  307.             param1 = param2;
  308.          }
  309.          else if(param1 > param3)
  310.          {
  311.             param1 = param3;
  312.          }
  313.          else
  314.          {
  315.             param1 = Math.floor(param1);
  316.          }
  317.          return param1;
  318.       }
  319.       
  320.       private function shareRowSpace(param1:ContentRowChild, param2:Number) : Number
  321.       {
  322.          var _loc11_:Number = NaN;
  323.          var _loc12_:Number = NaN;
  324.          var _loc13_:Number = NaN;
  325.          var _loc3_:ConstraintRow = param1.topRow;
  326.          var _loc4_:ConstraintRow = param1.bottomRow;
  327.          var _loc5_:IUIComponent = param1.child;
  328.          var _loc6_:Number = 0;
  329.          var _loc7_:Number = 0;
  330.          var _loc8_:Number = !!param1.topOffset ? param1.topOffset : 0;
  331.          var _loc9_:Number = !!param1.bottomOffset ? param1.bottomOffset : 0;
  332.          if(Boolean(_loc3_) && Boolean(_loc3_.height))
  333.          {
  334.             _loc6_ += _loc3_.height;
  335.          }
  336.          else if(Boolean(_loc4_) && !_loc3_)
  337.          {
  338.             _loc3_ = IConstraintLayout(target).constraintRows[param1.bottom - 2];
  339.             if(Boolean(_loc3_) && Boolean(_loc3_.height))
  340.             {
  341.                _loc6_ += _loc3_.height;
  342.             }
  343.          }
  344.          if(Boolean(_loc4_) && Boolean(_loc4_.height))
  345.          {
  346.             _loc7_ += _loc4_.height;
  347.          }
  348.          else if(Boolean(_loc3_) && !_loc4_)
  349.          {
  350.             _loc4_ = IConstraintLayout(target).constraintRows[param1.top + 1];
  351.             if((Boolean(_loc4_)) && Boolean(_loc4_.height))
  352.             {
  353.                _loc7_ += _loc4_.height;
  354.             }
  355.          }
  356.          if(Boolean(_loc3_) && isNaN(_loc3_.height))
  357.          {
  358.             _loc3_.setActualHeight(Math.max(0,_loc3_.maxHeight));
  359.          }
  360.          if(Boolean(_loc4_) && isNaN(_loc4_.height))
  361.          {
  362.             _loc4_.setActualHeight(Math.max(0,_loc4_.height));
  363.          }
  364.          var _loc10_:Number = Number(_loc5_.getExplicitOrMeasuredHeight());
  365.          if(_loc10_)
  366.          {
  367.             if(!param1.topRow)
  368.             {
  369.                if(_loc10_ > _loc6_)
  370.                {
  371.                   _loc12_ = _loc10_ - _loc6_ + _loc9_;
  372.                }
  373.                else
  374.                {
  375.                   _loc12_ = _loc10_ + _loc9_;
  376.                }
  377.             }
  378.             if(!param1.bottomRow)
  379.             {
  380.                if(_loc10_ > _loc7_)
  381.                {
  382.                   _loc11_ = _loc10_ - _loc7_ + _loc8_;
  383.                }
  384.                else
  385.                {
  386.                   _loc11_ = _loc10_ + _loc8_;
  387.                }
  388.             }
  389.             if(Boolean(param1.topRow) && Boolean(param1.bottomRow))
  390.             {
  391.                _loc13_ = _loc10_ / Number(param1.span);
  392.                if(_loc13_ + _loc8_ < _loc6_)
  393.                {
  394.                   _loc11_ = _loc6_;
  395.                   _loc12_ = _loc10_ - (_loc6_ - _loc8_) + _loc9_;
  396.                }
  397.                else
  398.                {
  399.                   _loc11_ = _loc13_ + _loc8_;
  400.                }
  401.                if(_loc13_ + _loc9_ < _loc7_)
  402.                {
  403.                   _loc12_ = _loc7_;
  404.                   _loc11_ = _loc10_ - (_loc7_ - _loc9_) + _loc8_;
  405.                }
  406.                else
  407.                {
  408.                   _loc12_ = _loc13_ + _loc9_;
  409.                }
  410.             }
  411.             _loc12_ = bound(_loc12_,_loc4_.minHeight,_loc4_.maxHeight);
  412.             _loc4_.setActualHeight(_loc12_);
  413.             param2 -= _loc12_;
  414.             _loc11_ = bound(_loc11_,_loc3_.minHeight,_loc3_.maxHeight);
  415.             _loc3_.setActualHeight(_loc11_);
  416.             param2 -= _loc11_;
  417.          }
  418.          return param2;
  419.       }
  420.       
  421.       private function parseConstraintExp(param1:String) : Array
  422.       {
  423.          if(!param1)
  424.          {
  425.             return null;
  426.          }
  427.          var _loc2_:String = param1.replace(/:/g," ");
  428.          return _loc2_.split(/\s+/);
  429.       }
  430.       
  431.       private function measureColumnsAndRows() : void
  432.       {
  433.          var _loc3_:int = 0;
  434.          var _loc4_:int = 0;
  435.          var _loc13_:ConstraintColumn = null;
  436.          var _loc14_:ConstraintRow = null;
  437.          var _loc15_:Number = NaN;
  438.          var _loc16_:Number = NaN;
  439.          var _loc17_:Number = NaN;
  440.          var _loc18_:Number = NaN;
  441.          var _loc19_:ContentColumnChild = null;
  442.          var _loc20_:ContentRowChild = null;
  443.          var _loc1_:Array = IConstraintLayout(target).constraintColumns;
  444.          var _loc2_:Array = IConstraintLayout(target).constraintRows;
  445.          if(!_loc2_.length > 0 && !_loc1_.length > 0)
  446.          {
  447.             constraintRegionsInUse = false;
  448.             return;
  449.          }
  450.          constraintRegionsInUse = true;
  451.          var _loc5_:Number = 0;
  452.          var _loc6_:Number = 0;
  453.          var _loc7_:EdgeMetrics = Container(target).viewMetrics;
  454.          var _loc8_:Number = Container(target).width - _loc7_.left - _loc7_.right;
  455.          var _loc9_:Number = Container(target).height - _loc7_.top - _loc7_.bottom;
  456.          var _loc10_:Array = [];
  457.          var _loc11_:Array = [];
  458.          var _loc12_:Array = [];
  459.          if(_loc1_.length > 0)
  460.          {
  461.             _loc3_ = 0;
  462.             while(_loc3_ < _loc1_.length)
  463.             {
  464.                _loc13_ = _loc1_[_loc3_];
  465.                if(!isNaN(_loc13_.percentWidth))
  466.                {
  467.                   _loc11_.push(_loc13_);
  468.                }
  469.                else if(!isNaN(_loc13_.width) && !_loc13_.mx_internal::contentSize)
  470.                {
  471.                   _loc10_.push(_loc13_);
  472.                }
  473.                else
  474.                {
  475.                   _loc12_.push(_loc13_);
  476.                   _loc13_.mx_internal::contentSize = true;
  477.                }
  478.                _loc3_++;
  479.             }
  480.             _loc3_ = 0;
  481.             while(_loc3_ < _loc10_.length)
  482.             {
  483.                _loc13_ = ConstraintColumn(_loc10_[_loc3_]);
  484.                _loc8_ -= _loc13_.width;
  485.                _loc3_++;
  486.             }
  487.             if(_loc12_.length > 0)
  488.             {
  489.                if(colSpanChildren.length > 0)
  490.                {
  491.                   colSpanChildren.sortOn("span");
  492.                   _loc4_ = 0;
  493.                   while(_loc4_ < colSpanChildren.length)
  494.                   {
  495.                      _loc19_ = colSpanChildren[_loc4_];
  496.                      if(_loc19_.span == 1)
  497.                      {
  498.                         if(_loc19_.hcCol)
  499.                         {
  500.                            _loc13_ = ConstraintColumn(_loc1_[_loc1_.indexOf(_loc19_.hcCol)]);
  501.                         }
  502.                         else if(_loc19_.leftCol)
  503.                         {
  504.                            _loc13_ = ConstraintColumn(_loc1_[_loc1_.indexOf(_loc19_.leftCol)]);
  505.                         }
  506.                         else if(_loc19_.rightCol)
  507.                         {
  508.                            _loc13_ = ConstraintColumn(_loc1_[_loc1_.indexOf(_loc19_.rightCol)]);
  509.                         }
  510.                         _loc16_ = Number(_loc19_.child.getExplicitOrMeasuredWidth());
  511.                         if(_loc19_.hcOffset)
  512.                         {
  513.                            _loc16_ += _loc19_.hcOffset;
  514.                         }
  515.                         else
  516.                         {
  517.                            if(_loc19_.leftOffset)
  518.                            {
  519.                               _loc16_ += _loc19_.leftOffset;
  520.                            }
  521.                            if(_loc19_.rightOffset)
  522.                            {
  523.                               _loc16_ += _loc19_.rightOffset;
  524.                            }
  525.                         }
  526.                         if(!isNaN(_loc13_.width))
  527.                         {
  528.                            _loc16_ = Math.max(_loc13_.width,_loc16_);
  529.                         }
  530.                         _loc16_ = bound(_loc16_,_loc13_.minWidth,_loc13_.maxWidth);
  531.                         _loc13_.setActualWidth(_loc16_);
  532.                         _loc8_ -= _loc13_.width;
  533.                      }
  534.                      else
  535.                      {
  536.                         _loc8_ = shareColumnSpace(_loc19_,_loc8_);
  537.                      }
  538.                      _loc4_++;
  539.                   }
  540.                   colSpanChildren = [];
  541.                }
  542.                _loc3_ = 0;
  543.                while(_loc3_ < _loc12_.length)
  544.                {
  545.                   _loc13_ = _loc12_[_loc3_];
  546.                   if(!_loc13_.width)
  547.                   {
  548.                      _loc16_ = bound(0,_loc13_.minWidth,0);
  549.                      _loc13_.setActualWidth(_loc16_);
  550.                   }
  551.                   _loc3_++;
  552.                }
  553.             }
  554.             _loc18_ = _loc8_;
  555.             _loc3_ = 0;
  556.             while(_loc3_ < _loc11_.length)
  557.             {
  558.                _loc13_ = ConstraintColumn(_loc11_[_loc3_]);
  559.                if(_loc18_ <= 0)
  560.                {
  561.                   _loc16_ = 0;
  562.                }
  563.                else
  564.                {
  565.                   _loc16_ = Math.round(_loc18_ * _loc13_.percentWidth / 100);
  566.                }
  567.                _loc16_ = bound(_loc16_,_loc13_.minWidth,_loc13_.maxWidth);
  568.                _loc13_.setActualWidth(_loc16_);
  569.                _loc8_ -= _loc16_;
  570.                _loc3_++;
  571.             }
  572.             _loc3_ = 0;
  573.             while(_loc3_ < _loc1_.length)
  574.             {
  575.                _loc13_ = ConstraintColumn(_loc1_[_loc3_]);
  576.                _loc13_.x = _loc5_;
  577.                _loc5_ += _loc13_.width;
  578.                _loc3_++;
  579.             }
  580.          }
  581.          _loc10_ = [];
  582.          _loc11_ = [];
  583.          _loc12_ = [];
  584.          if(_loc2_.length > 0)
  585.          {
  586.             _loc3_ = 0;
  587.             while(_loc3_ < _loc2_.length)
  588.             {
  589.                _loc14_ = _loc2_[_loc3_];
  590.                if(!isNaN(_loc14_.percentHeight))
  591.                {
  592.                   _loc11_.push(_loc14_);
  593.                }
  594.                else if(!isNaN(_loc14_.height) && !_loc14_.mx_internal::contentSize)
  595.                {
  596.                   _loc10_.push(_loc14_);
  597.                }
  598.                else
  599.                {
  600.                   _loc12_.push(_loc14_);
  601.                   _loc14_.mx_internal::contentSize = true;
  602.                }
  603.                _loc3_++;
  604.             }
  605.             _loc3_ = 0;
  606.             while(_loc3_ < _loc10_.length)
  607.             {
  608.                _loc14_ = ConstraintRow(_loc10_[_loc3_]);
  609.                _loc9_ -= _loc14_.height;
  610.                _loc3_++;
  611.             }
  612.             if(_loc12_.length > 0)
  613.             {
  614.                if(rowSpanChildren.length > 0)
  615.                {
  616.                   rowSpanChildren.sortOn("span");
  617.                   _loc4_ = 0;
  618.                   while(_loc4_ < rowSpanChildren.length)
  619.                   {
  620.                      _loc20_ = rowSpanChildren[_loc4_];
  621.                      if(_loc20_.span == 1)
  622.                      {
  623.                         if(_loc20_.vcRow)
  624.                         {
  625.                            _loc14_ = ConstraintRow(_loc2_[_loc2_.indexOf(_loc20_.vcRow)]);
  626.                         }
  627.                         else if(_loc20_.baselineRow)
  628.                         {
  629.                            _loc14_ = ConstraintRow(_loc2_[_loc2_.indexOf(_loc20_.baselineRow)]);
  630.                         }
  631.                         else if(_loc20_.topRow)
  632.                         {
  633.                            _loc14_ = ConstraintRow(_loc2_[_loc2_.indexOf(_loc20_.topRow)]);
  634.                         }
  635.                         else if(_loc20_.bottomRow)
  636.                         {
  637.                            _loc14_ = ConstraintRow(_loc2_[_loc2_.indexOf(_loc20_.bottomRow)]);
  638.                         }
  639.                         _loc17_ = Number(_loc20_.child.getExplicitOrMeasuredHeight());
  640.                         if(_loc20_.baselineOffset)
  641.                         {
  642.                            _loc17_ += _loc20_.baselineOffset;
  643.                         }
  644.                         else if(_loc20_.vcOffset)
  645.                         {
  646.                            _loc17_ += _loc20_.vcOffset;
  647.                         }
  648.                         else
  649.                         {
  650.                            if(_loc20_.topOffset)
  651.                            {
  652.                               _loc17_ += _loc20_.topOffset;
  653.                            }
  654.                            if(_loc20_.bottomOffset)
  655.                            {
  656.                               _loc17_ += _loc20_.bottomOffset;
  657.                            }
  658.                         }
  659.                         if(!isNaN(_loc14_.height))
  660.                         {
  661.                            _loc17_ = Math.max(_loc14_.height,_loc17_);
  662.                         }
  663.                         _loc17_ = bound(_loc17_,_loc14_.minHeight,_loc14_.maxHeight);
  664.                         _loc14_.setActualHeight(_loc17_);
  665.                         _loc9_ -= _loc14_.height;
  666.                      }
  667.                      else
  668.                      {
  669.                         _loc9_ = shareRowSpace(_loc20_,_loc9_);
  670.                      }
  671.                      _loc4_++;
  672.                   }
  673.                   rowSpanChildren = [];
  674.                }
  675.                _loc3_ = 0;
  676.                while(_loc3_ < _loc12_.length)
  677.                {
  678.                   _loc14_ = ConstraintRow(_loc12_[_loc3_]);
  679.                   if(!_loc14_.height)
  680.                   {
  681.                      _loc17_ = bound(0,_loc14_.minHeight,0);
  682.                      _loc14_.setActualHeight(_loc17_);
  683.                   }
  684.                   _loc3_++;
  685.                }
  686.             }
  687.             _loc18_ = _loc9_;
  688.             _loc3_ = 0;
  689.             while(_loc3_ < _loc11_.length)
  690.             {
  691.                _loc14_ = ConstraintRow(_loc11_[_loc3_]);
  692.                if(_loc18_ <= 0)
  693.                {
  694.                   _loc17_ = 0;
  695.                }
  696.                else
  697.                {
  698.                   _loc17_ = Math.round(_loc18_ * _loc14_.percentHeight / 100);
  699.                }
  700.                _loc17_ = bound(_loc17_,_loc14_.minHeight,_loc14_.maxHeight);
  701.                _loc14_.setActualHeight(_loc17_);
  702.                _loc9_ -= _loc17_;
  703.                _loc3_++;
  704.             }
  705.             _loc3_ = 0;
  706.             while(_loc3_ < _loc2_.length)
  707.             {
  708.                _loc14_ = _loc2_[_loc3_];
  709.                _loc14_.y = _loc6_;
  710.                _loc6_ += _loc14_.height;
  711.                _loc3_++;
  712.             }
  713.          }
  714.       }
  715.       
  716.       private function child_moveHandler(param1:MoveEvent) : void
  717.       {
  718.          if(param1.target is IUIComponent)
  719.          {
  720.             if(!IUIComponent(param1.target).includeInLayout)
  721.             {
  722.                return;
  723.             }
  724.          }
  725.          var _loc2_:Container = super.target;
  726.          if(_loc2_)
  727.          {
  728.             _loc2_.invalidateSize();
  729.             _loc2_.invalidateDisplayList();
  730.             _contentArea = null;
  731.          }
  732.       }
  733.       
  734.       private function applyAnchorStylesDuringMeasure(param1:IUIComponent, param2:Rectangle) : void
  735.       {
  736.          var _loc13_:int = 0;
  737.          var _loc3_:IConstraintClient = param1 as IConstraintClient;
  738.          if(!_loc3_)
  739.          {
  740.             return;
  741.          }
  742.          var _loc4_:ChildConstraintInfo = constraintCache[_loc3_];
  743.          if(!_loc4_)
  744.          {
  745.             _loc4_ = parseConstraints(param1);
  746.          }
  747.          var _loc5_:Number = _loc4_.left;
  748.          var _loc6_:Number = _loc4_.right;
  749.          var _loc7_:Number = _loc4_.hc;
  750.          var _loc8_:Number = _loc4_.top;
  751.          var _loc9_:Number = _loc4_.bottom;
  752.          var _loc10_:Number = _loc4_.vc;
  753.          var _loc11_:Array = IConstraintLayout(target).constraintColumns;
  754.          var _loc12_:Array = IConstraintLayout(target).constraintRows;
  755.          var _loc14_:Number = 0;
  756.          if(!_loc11_.length > 0)
  757.          {
  758.             if(!isNaN(_loc7_))
  759.             {
  760.                param2.x = Math.round((target.width - param1.width) / 2 + _loc7_);
  761.             }
  762.             else if(!isNaN(_loc5_) && !isNaN(_loc6_))
  763.             {
  764.                param2.x = _loc5_;
  765.                param2.width += _loc6_;
  766.             }
  767.             else if(!isNaN(_loc5_))
  768.             {
  769.                param2.x = _loc5_;
  770.             }
  771.             else if(!isNaN(_loc6_))
  772.             {
  773.                param2.x = 0;
  774.                param2.width += _loc6_;
  775.             }
  776.          }
  777.          else
  778.          {
  779.             param2.x = 0;
  780.             _loc13_ = 0;
  781.             while(_loc13_ < _loc11_.length)
  782.             {
  783.                _loc14_ += ConstraintColumn(_loc11_[_loc13_]).width;
  784.                _loc13_++;
  785.             }
  786.             param2.width = _loc14_;
  787.          }
  788.          if(!_loc12_.length > 0)
  789.          {
  790.             if(!isNaN(_loc10_))
  791.             {
  792.                param2.y = Math.round((target.height - param1.height) / 2 + _loc10_);
  793.             }
  794.             else if(!isNaN(_loc8_) && !isNaN(_loc9_))
  795.             {
  796.                param2.y = _loc8_;
  797.                param2.height += _loc9_;
  798.             }
  799.             else if(!isNaN(_loc8_))
  800.             {
  801.                param2.y = _loc8_;
  802.             }
  803.             else if(!isNaN(_loc9_))
  804.             {
  805.                param2.y = 0;
  806.                param2.height += _loc9_;
  807.             }
  808.          }
  809.          else
  810.          {
  811.             _loc14_ = 0;
  812.             param2.y = 0;
  813.             _loc13_ = 0;
  814.             while(_loc13_ < _loc12_.length)
  815.             {
  816.                _loc14_ += ConstraintRow(_loc12_[_loc13_]).height;
  817.                _loc13_++;
  818.             }
  819.             param2.height = _loc14_;
  820.          }
  821.       }
  822.       
  823.       override public function measure() : void
  824.       {
  825.          var _loc1_:Container = null;
  826.          var _loc5_:EdgeMetrics = null;
  827.          var _loc6_:Rectangle = null;
  828.          var _loc7_:IUIComponent = null;
  829.          var _loc8_:ConstraintColumn = null;
  830.          var _loc9_:ConstraintRow = null;
  831.          _loc1_ = super.target;
  832.          var _loc2_:Number = 0;
  833.          var _loc3_:Number = 0;
  834.          var _loc4_:Number = 0;
  835.          _loc5_ = _loc1_.viewMetrics;
  836.          _loc4_ = 0;
  837.          while(_loc4_ < _loc1_.numChildren)
  838.          {
  839.             _loc7_ = _loc1_.getChildAt(_loc4_) as IUIComponent;
  840.             parseConstraints(_loc7_);
  841.             _loc4_++;
  842.          }
  843.          _loc4_ = 0;
  844.          while(_loc4_ < IConstraintLayout(_loc1_).constraintColumns.length)
  845.          {
  846.             _loc8_ = IConstraintLayout(_loc1_).constraintColumns[_loc4_];
  847.             if(_loc8_.mx_internal::contentSize)
  848.             {
  849.                _loc8_.mx_internal::_width = NaN;
  850.             }
  851.             _loc4_++;
  852.          }
  853.          _loc4_ = 0;
  854.          while(_loc4_ < IConstraintLayout(_loc1_).constraintRows.length)
  855.          {
  856.             _loc9_ = IConstraintLayout(_loc1_).constraintRows[_loc4_];
  857.             if(_loc9_.mx_internal::contentSize)
  858.             {
  859.                _loc9_.mx_internal::_height = NaN;
  860.             }
  861.             _loc4_++;
  862.          }
  863.          measureColumnsAndRows();
  864.          _contentArea = null;
  865.          _loc6_ = measureContentArea();
  866.          _loc1_.measuredWidth = _loc6_.width + _loc5_.left + _loc5_.right;
  867.          _loc1_.measuredHeight = _loc6_.height + _loc5_.top + _loc5_.bottom;
  868.       }
  869.       
  870.       private function target_childRemoveHandler(param1:ChildExistenceChangedEvent) : void
  871.       {
  872.          DisplayObject(param1.relatedObject).removeEventListener(MoveEvent.MOVE,child_moveHandler);
  873.          delete constraintCache[param1.relatedObject];
  874.       }
  875.       
  876.       override public function set target(param1:Container) : void
  877.       {
  878.          var _loc3_:int = 0;
  879.          var _loc4_:int = 0;
  880.          var _loc2_:Container = super.target;
  881.          if(param1 != _loc2_)
  882.          {
  883.             if(_loc2_)
  884.             {
  885.                _loc2_.removeEventListener(ChildExistenceChangedEvent.CHILD_ADD,target_childAddHandler);
  886.                _loc2_.removeEventListener(ChildExistenceChangedEvent.CHILD_REMOVE,target_childRemoveHandler);
  887.                _loc4_ = _loc2_.numChildren;
  888.                _loc3_ = 0;
  889.                while(_loc3_ < _loc4_)
  890.                {
  891.                   DisplayObject(_loc2_.getChildAt(_loc3_)).removeEventListener(MoveEvent.MOVE,child_moveHandler);
  892.                   _loc3_++;
  893.                }
  894.             }
  895.             if(param1)
  896.             {
  897.                param1.addEventListener(ChildExistenceChangedEvent.CHILD_ADD,target_childAddHandler);
  898.                param1.addEventListener(ChildExistenceChangedEvent.CHILD_REMOVE,target_childRemoveHandler);
  899.                _loc4_ = param1.numChildren;
  900.                _loc3_ = 0;
  901.                while(_loc3_ < _loc4_)
  902.                {
  903.                   DisplayObject(param1.getChildAt(_loc3_)).addEventListener(MoveEvent.MOVE,child_moveHandler);
  904.                   _loc3_++;
  905.                }
  906.             }
  907.             super.target = param1;
  908.          }
  909.       }
  910.       
  911.       private function measureContentArea() : Rectangle
  912.       {
  913.          var _loc1_:int = 0;
  914.          var _loc3_:Array = null;
  915.          var _loc4_:Array = null;
  916.          var _loc5_:IUIComponent = null;
  917.          var _loc6_:LayoutConstraints = null;
  918.          var _loc7_:Number = NaN;
  919.          var _loc8_:Number = NaN;
  920.          var _loc9_:Number = NaN;
  921.          var _loc10_:Number = NaN;
  922.          var _loc11_:Number = NaN;
  923.          var _loc12_:Number = NaN;
  924.          if(_contentArea)
  925.          {
  926.             return _contentArea;
  927.          }
  928.          _contentArea = new Rectangle();
  929.          var _loc2_:int = target.numChildren;
  930.          if(_loc2_ == 0 && constraintRegionsInUse)
  931.          {
  932.             _loc3_ = IConstraintLayout(target).constraintColumns;
  933.             _loc4_ = IConstraintLayout(target).constraintRows;
  934.             if(_loc3_.length > 0)
  935.             {
  936.                _contentArea.right = _loc3_[_loc3_.length - 1].x + _loc3_[_loc3_.length - 1].width;
  937.             }
  938.             else
  939.             {
  940.                _contentArea.right = 0;
  941.             }
  942.             if(_loc4_.length > 0)
  943.             {
  944.                _contentArea.bottom = _loc4_[_loc4_.length - 1].y + _loc4_[_loc4_.length - 1].height;
  945.             }
  946.             else
  947.             {
  948.                _contentArea.bottom = 0;
  949.             }
  950.          }
  951.          _loc1_ = 0;
  952.          while(_loc1_ < _loc2_)
  953.          {
  954.             _loc5_ = target.getChildAt(_loc1_) as IUIComponent;
  955.             _loc6_ = getLayoutConstraints(_loc5_);
  956.             if(_loc5_.includeInLayout)
  957.             {
  958.                _loc7_ = Number(_loc5_.x);
  959.                _loc8_ = Number(_loc5_.y);
  960.                _loc9_ = Number(_loc5_.getExplicitOrMeasuredWidth());
  961.                _loc10_ = Number(_loc5_.getExplicitOrMeasuredHeight());
  962.                if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  963.                {
  964.                   if(!isNaN(_loc5_.percentWidth) || _loc6_ && !isNaN(_loc6_.left) && !isNaN(_loc6_.right))
  965.                   {
  966.                      _loc9_ = Number(_loc5_.minWidth);
  967.                   }
  968.                }
  969.                else if(!isNaN(_loc5_.percentWidth) || _loc6_ && !isNaN(_loc6_.left) && !isNaN(_loc6_.right) && isNaN(_loc5_.explicitWidth))
  970.                {
  971.                   _loc9_ = Number(_loc5_.minWidth);
  972.                }
  973.                if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  974.                {
  975.                   if(!isNaN(_loc5_.percentHeight) || _loc6_ && !isNaN(_loc6_.top) && !isNaN(_loc6_.bottom))
  976.                   {
  977.                      _loc10_ = Number(_loc5_.minHeight);
  978.                   }
  979.                }
  980.                else if(!isNaN(_loc5_.percentHeight) || _loc6_ && !isNaN(_loc6_.top) && !isNaN(_loc6_.bottom) && isNaN(_loc5_.explicitHeight))
  981.                {
  982.                   _loc10_ = Number(_loc5_.minHeight);
  983.                }
  984.                r.x = _loc7_;
  985.                r.y = _loc8_;
  986.                r.width = _loc9_;
  987.                r.height = _loc10_;
  988.                applyAnchorStylesDuringMeasure(_loc5_,r);
  989.                _loc7_ = r.x;
  990.                _loc8_ = r.y;
  991.                _loc9_ = r.width;
  992.                _loc10_ = r.height;
  993.                if(isNaN(_loc7_))
  994.                {
  995.                   _loc7_ = Number(_loc5_.x);
  996.                }
  997.                if(isNaN(_loc8_))
  998.                {
  999.                   _loc8_ = Number(_loc5_.y);
  1000.                }
  1001.                _loc11_ = _loc7_;
  1002.                _loc12_ = _loc8_;
  1003.                if(isNaN(_loc9_))
  1004.                {
  1005.                   _loc9_ = Number(_loc5_.width);
  1006.                }
  1007.                if(isNaN(_loc10_))
  1008.                {
  1009.                   _loc10_ = Number(_loc5_.height);
  1010.                }
  1011.                _loc11_ += _loc9_;
  1012.                _loc12_ += _loc10_;
  1013.                _contentArea.right = Math.max(_contentArea.right,_loc11_);
  1014.                _contentArea.bottom = Math.max(_contentArea.bottom,_loc12_);
  1015.             }
  1016.             _loc1_++;
  1017.          }
  1018.          return _contentArea;
  1019.       }
  1020.       
  1021.       private function shareColumnSpace(param1:ContentColumnChild, param2:Number) : Number
  1022.       {
  1023.          var _loc11_:Number = NaN;
  1024.          var _loc12_:Number = NaN;
  1025.          var _loc13_:Number = NaN;
  1026.          var _loc3_:ConstraintColumn = param1.leftCol;
  1027.          var _loc4_:ConstraintColumn = param1.rightCol;
  1028.          var _loc5_:IUIComponent = param1.child;
  1029.          var _loc6_:Number = 0;
  1030.          var _loc7_:Number = 0;
  1031.          var _loc8_:Number = !!param1.rightOffset ? param1.rightOffset : 0;
  1032.          var _loc9_:Number = !!param1.leftOffset ? param1.leftOffset : 0;
  1033.          if(Boolean(_loc3_) && Boolean(_loc3_.width))
  1034.          {
  1035.             _loc6_ += _loc3_.width;
  1036.          }
  1037.          else if(Boolean(_loc4_) && !_loc3_)
  1038.          {
  1039.             _loc3_ = IConstraintLayout(target).constraintColumns[param1.right - 2];
  1040.             if(Boolean(_loc3_) && Boolean(_loc3_.width))
  1041.             {
  1042.                _loc6_ += _loc3_.width;
  1043.             }
  1044.          }
  1045.          if(Boolean(_loc4_) && Boolean(_loc4_.width))
  1046.          {
  1047.             _loc7_ += _loc4_.width;
  1048.          }
  1049.          else if(Boolean(_loc3_) && !_loc4_)
  1050.          {
  1051.             _loc4_ = IConstraintLayout(target).constraintColumns[param1.left + 1];
  1052.             if((Boolean(_loc4_)) && Boolean(_loc4_.width))
  1053.             {
  1054.                _loc7_ += _loc4_.width;
  1055.             }
  1056.          }
  1057.          if(Boolean(_loc3_) && isNaN(_loc3_.width))
  1058.          {
  1059.             _loc3_.setActualWidth(Math.max(0,_loc3_.maxWidth));
  1060.          }
  1061.          if(Boolean(_loc4_) && isNaN(_loc4_.width))
  1062.          {
  1063.             _loc4_.setActualWidth(Math.max(0,_loc4_.maxWidth));
  1064.          }
  1065.          var _loc10_:Number = Number(_loc5_.getExplicitOrMeasuredWidth());
  1066.          if(_loc10_)
  1067.          {
  1068.             if(!param1.leftCol)
  1069.             {
  1070.                if(_loc10_ > _loc6_)
  1071.                {
  1072.                   _loc12_ = _loc10_ - _loc6_ + _loc8_;
  1073.                }
  1074.                else
  1075.                {
  1076.                   _loc12_ = _loc10_ + _loc8_;
  1077.                }
  1078.             }
  1079.             if(!param1.rightCol)
  1080.             {
  1081.                if(_loc10_ > _loc7_)
  1082.                {
  1083.                   _loc11_ = _loc10_ - _loc7_ + _loc9_;
  1084.                }
  1085.                else
  1086.                {
  1087.                   _loc11_ = _loc10_ + _loc9_;
  1088.                }
  1089.             }
  1090.             if(Boolean(param1.leftCol) && Boolean(param1.rightCol))
  1091.             {
  1092.                _loc13_ = _loc10_ / Number(param1.span);
  1093.                if(_loc13_ + _loc9_ < _loc6_)
  1094.                {
  1095.                   _loc11_ = _loc6_;
  1096.                   _loc12_ = _loc10_ - (_loc6_ - _loc9_) + _loc8_;
  1097.                }
  1098.                else
  1099.                {
  1100.                   _loc11_ = _loc13_ + _loc9_;
  1101.                }
  1102.                if(_loc13_ + _loc8_ < _loc7_)
  1103.                {
  1104.                   _loc12_ = _loc7_;
  1105.                   _loc11_ = _loc10_ - (_loc7_ - _loc8_) + _loc9_;
  1106.                }
  1107.                else
  1108.                {
  1109.                   _loc12_ = _loc13_ + _loc8_;
  1110.                }
  1111.             }
  1112.             _loc11_ = bound(_loc11_,_loc3_.minWidth,_loc3_.maxWidth);
  1113.             _loc3_.setActualWidth(_loc11_);
  1114.             param2 -= _loc11_;
  1115.             _loc12_ = bound(_loc12_,_loc4_.minWidth,_loc4_.maxWidth);
  1116.             _loc4_.setActualWidth(_loc12_);
  1117.             param2 -= _loc12_;
  1118.          }
  1119.          return param2;
  1120.       }
  1121.       
  1122.       private function getLayoutConstraints(param1:IUIComponent) : LayoutConstraints
  1123.       {
  1124.          var _loc2_:IConstraintClient = param1 as IConstraintClient;
  1125.          if(!_loc2_)
  1126.          {
  1127.             return null;
  1128.          }
  1129.          var _loc3_:LayoutConstraints = new LayoutConstraints();
  1130.          _loc3_.baseline = _loc2_.getConstraintValue("baseline");
  1131.          _loc3_.bottom = _loc2_.getConstraintValue("bottom");
  1132.          _loc3_.horizontalCenter = _loc2_.getConstraintValue("horizontalCenter");
  1133.          _loc3_.left = _loc2_.getConstraintValue("left");
  1134.          _loc3_.right = _loc2_.getConstraintValue("right");
  1135.          _loc3_.top = _loc2_.getConstraintValue("top");
  1136.          _loc3_.verticalCenter = _loc2_.getConstraintValue("verticalCenter");
  1137.          return _loc3_;
  1138.       }
  1139.       
  1140.       override public function updateDisplayList(param1:Number, param2:Number) : void
  1141.       {
  1142.          var _loc3_:int = 0;
  1143.          var _loc4_:IUIComponent = null;
  1144.          var _loc10_:ConstraintColumn = null;
  1145.          var _loc11_:ConstraintRow = null;
  1146.          var _loc5_:Container = super.target;
  1147.          var _loc6_:int = _loc5_.numChildren;
  1148.          _loc5_.mx_internal::doingLayout = false;
  1149.          var _loc7_:EdgeMetrics = _loc5_.viewMetrics;
  1150.          _loc5_.mx_internal::doingLayout = true;
  1151.          var _loc8_:Number = param1 - _loc7_.left - _loc7_.right;
  1152.          var _loc9_:Number = param2 - _loc7_.top - _loc7_.bottom;
  1153.          if(IConstraintLayout(_loc5_).constraintColumns.length > 0 || IConstraintLayout(_loc5_).constraintRows.length > 0)
  1154.          {
  1155.             constraintRegionsInUse = true;
  1156.          }
  1157.          if(constraintRegionsInUse)
  1158.          {
  1159.             _loc3_ = 0;
  1160.             while(_loc3_ < _loc6_)
  1161.             {
  1162.                _loc4_ = _loc5_.getChildAt(_loc3_) as IUIComponent;
  1163.                parseConstraints(_loc4_);
  1164.                _loc3_++;
  1165.             }
  1166.             _loc3_ = 0;
  1167.             while(_loc3_ < IConstraintLayout(_loc5_).constraintColumns.length)
  1168.             {
  1169.                _loc10_ = IConstraintLayout(_loc5_).constraintColumns[_loc3_];
  1170.                if(_loc10_.mx_internal::contentSize)
  1171.                {
  1172.                   _loc10_.mx_internal::_width = NaN;
  1173.                }
  1174.                _loc3_++;
  1175.             }
  1176.             _loc3_ = 0;
  1177.             while(_loc3_ < IConstraintLayout(_loc5_).constraintRows.length)
  1178.             {
  1179.                _loc11_ = IConstraintLayout(_loc5_).constraintRows[_loc3_];
  1180.                if(_loc11_.mx_internal::contentSize)
  1181.                {
  1182.                   _loc11_.mx_internal::_height = NaN;
  1183.                }
  1184.                _loc3_++;
  1185.             }
  1186.             measureColumnsAndRows();
  1187.          }
  1188.          _loc3_ = 0;
  1189.          while(_loc3_ < _loc6_)
  1190.          {
  1191.             _loc4_ = _loc5_.getChildAt(_loc3_) as IUIComponent;
  1192.             applyAnchorStylesDuringUpdateDisplayList(_loc8_,_loc9_,_loc4_);
  1193.             _loc3_++;
  1194.          }
  1195.       }
  1196.       
  1197.       private function applyAnchorStylesDuringUpdateDisplayList(param1:Number, param2:Number, param3:IUIComponent = null) : void
  1198.       {
  1199.          var _loc20_:int = 0;
  1200.          var _loc21_:Number = NaN;
  1201.          var _loc22_:Number = NaN;
  1202.          var _loc23_:Number = NaN;
  1203.          var _loc24_:Number = NaN;
  1204.          var _loc25_:String = null;
  1205.          var _loc34_:Number = NaN;
  1206.          var _loc35_:Number = NaN;
  1207.          var _loc36_:Number = NaN;
  1208.          var _loc37_:Number = NaN;
  1209.          var _loc38_:Number = NaN;
  1210.          var _loc39_:Boolean = false;
  1211.          var _loc40_:Boolean = false;
  1212.          var _loc41_:Boolean = false;
  1213.          var _loc42_:ConstraintColumn = null;
  1214.          var _loc43_:Boolean = false;
  1215.          var _loc44_:Boolean = false;
  1216.          var _loc45_:Boolean = false;
  1217.          var _loc46_:Boolean = false;
  1218.          var _loc47_:ConstraintRow = null;
  1219.          var _loc4_:IConstraintClient = param3 as IConstraintClient;
  1220.          if(!_loc4_)
  1221.          {
  1222.             return;
  1223.          }
  1224.          var _loc5_:ChildConstraintInfo = parseConstraints(param3);
  1225.          var _loc6_:Number = _loc5_.left;
  1226.          var _loc7_:Number = _loc5_.right;
  1227.          var _loc8_:Number = _loc5_.hc;
  1228.          var _loc9_:Number = _loc5_.top;
  1229.          var _loc10_:Number = _loc5_.bottom;
  1230.          var _loc11_:Number = _loc5_.vc;
  1231.          var _loc12_:Number = _loc5_.baseline;
  1232.          var _loc13_:String = _loc5_.leftBoundary;
  1233.          var _loc14_:String = _loc5_.rightBoundary;
  1234.          var _loc15_:String = _loc5_.hcBoundary;
  1235.          var _loc16_:String = _loc5_.topBoundary;
  1236.          var _loc17_:String = _loc5_.bottomBoundary;
  1237.          var _loc18_:String = _loc5_.vcBoundary;
  1238.          var _loc19_:String = _loc5_.baselineBoundary;
  1239.          var _loc26_:Boolean = false;
  1240.          var _loc27_:Boolean = false;
  1241.          var _loc28_:Boolean = !_loc15_ && !_loc13_ && !_loc14_;
  1242.          var _loc29_:Boolean = !_loc18_ && !_loc16_ && !_loc17_ && !_loc19_;
  1243.          var _loc30_:Number = 0;
  1244.          var _loc31_:Number = param1;
  1245.          var _loc32_:Number = 0;
  1246.          var _loc33_:Number = param2;
  1247.          if(!_loc28_)
  1248.          {
  1249.             _loc39_ = !!_loc13_ ? true : false;
  1250.             _loc40_ = !!_loc14_ ? true : false;
  1251.             _loc41_ = !!_loc15_ ? true : false;
  1252.             _loc20_ = 0;
  1253.             while(_loc20_ < IConstraintLayout(target).constraintColumns.length)
  1254.             {
  1255.                _loc42_ = ConstraintColumn(IConstraintLayout(target).constraintColumns[_loc20_]);
  1256.                if(_loc39_)
  1257.                {
  1258.                   if(_loc13_ == _loc42_.id)
  1259.                   {
  1260.                      _loc30_ = _loc42_.x;
  1261.                      _loc39_ = false;
  1262.                   }
  1263.                }
  1264.                if(_loc40_)
  1265.                {
  1266.                   if(_loc14_ == _loc42_.id)
  1267.                   {
  1268.                      _loc31_ = _loc42_.x + _loc42_.width;
  1269.                      _loc40_ = false;
  1270.                   }
  1271.                }
  1272.                if(_loc41_)
  1273.                {
  1274.                   if(_loc15_ == _loc42_.id)
  1275.                   {
  1276.                      _loc35_ = _loc42_.width;
  1277.                      _loc37_ = _loc42_.x;
  1278.                      _loc41_ = false;
  1279.                   }
  1280.                }
  1281.                _loc20_++;
  1282.             }
  1283.             if(_loc39_)
  1284.             {
  1285.                _loc25_ = resourceManager.getString("containers","columnNotFound",[_loc13_]);
  1286.                throw new ConstraintError(_loc25_);
  1287.             }
  1288.             if(_loc40_)
  1289.             {
  1290.                _loc25_ = resourceManager.getString("containers","columnNotFound",[_loc14_]);
  1291.                throw new ConstraintError(_loc25_);
  1292.             }
  1293.             if(_loc41_)
  1294.             {
  1295.                _loc25_ = resourceManager.getString("containers","columnNotFound",[_loc15_]);
  1296.                throw new ConstraintError(_loc25_);
  1297.             }
  1298.          }
  1299.          else if(!_loc28_)
  1300.          {
  1301.             _loc25_ = resourceManager.getString("containers","noColumnsFound");
  1302.             throw new ConstraintError(_loc25_);
  1303.          }
  1304.          param1 = Math.round(_loc31_ - _loc30_);
  1305.          if(!isNaN(_loc6_) && !isNaN(_loc7_))
  1306.          {
  1307.             _loc21_ = param1 - _loc6_ - _loc7_;
  1308.             if(_loc21_ < param3.minWidth)
  1309.             {
  1310.                _loc21_ = Number(param3.minWidth);
  1311.             }
  1312.          }
  1313.          else if(!isNaN(param3.percentWidth))
  1314.          {
  1315.             _loc21_ = param3.percentWidth / 100 * param1;
  1316.             _loc21_ = bound(_loc21_,param3.minWidth,param3.maxWidth);
  1317.             _loc26_ = true;
  1318.          }
  1319.          else
  1320.          {
  1321.             _loc21_ = Number(param3.getExplicitOrMeasuredWidth());
  1322.          }
  1323.          if(!_loc29_ && IConstraintLayout(target).constraintRows.length > 0)
  1324.          {
  1325.             _loc43_ = !!_loc16_ ? true : false;
  1326.             _loc44_ = !!_loc17_ ? true : false;
  1327.             _loc45_ = !!_loc18_ ? true : false;
  1328.             _loc46_ = !!_loc19_ ? true : false;
  1329.             _loc20_ = 0;
  1330.             while(_loc20_ < IConstraintLayout(target).constraintRows.length)
  1331.             {
  1332.                _loc47_ = ConstraintRow(IConstraintLayout(target).constraintRows[_loc20_]);
  1333.                if(_loc43_)
  1334.                {
  1335.                   if(_loc16_ == _loc47_.id)
  1336.                   {
  1337.                      _loc32_ = _loc47_.y;
  1338.                      _loc43_ = false;
  1339.                   }
  1340.                }
  1341.                if(_loc44_)
  1342.                {
  1343.                   if(_loc17_ == _loc47_.id)
  1344.                   {
  1345.                      _loc33_ = _loc47_.y + _loc47_.height;
  1346.                      _loc44_ = false;
  1347.                   }
  1348.                }
  1349.                if(_loc45_)
  1350.                {
  1351.                   if(_loc18_ == _loc47_.id)
  1352.                   {
  1353.                      _loc34_ = _loc47_.height;
  1354.                      _loc36_ = _loc47_.y;
  1355.                      _loc45_ = false;
  1356.                   }
  1357.                }
  1358.                if(_loc46_)
  1359.                {
  1360.                   if(_loc19_ == _loc47_.id)
  1361.                   {
  1362.                      _loc38_ = _loc47_.y;
  1363.                      _loc46_ = false;
  1364.                   }
  1365.                }
  1366.                _loc20_++;
  1367.             }
  1368.             if(_loc43_)
  1369.             {
  1370.                _loc25_ = resourceManager.getString("containers","rowNotFound",[_loc16_]);
  1371.                throw new ConstraintError(_loc25_);
  1372.             }
  1373.             if(_loc44_)
  1374.             {
  1375.                _loc25_ = resourceManager.getString("containers","rowNotFound",[_loc17_]);
  1376.                throw new ConstraintError(_loc25_);
  1377.             }
  1378.             if(_loc45_)
  1379.             {
  1380.                _loc25_ = resourceManager.getString("containers","rowNotFound",[_loc18_]);
  1381.                throw new ConstraintError(_loc25_);
  1382.             }
  1383.             if(_loc46_)
  1384.             {
  1385.                _loc25_ = resourceManager.getString("containers","rowNotFound",[_loc19_]);
  1386.                throw new ConstraintError(_loc25_);
  1387.             }
  1388.          }
  1389.          else if(!_loc29_ && IConstraintLayout(target).constraintRows.length <= 0)
  1390.          {
  1391.             _loc25_ = resourceManager.getString("containers","noRowsFound");
  1392.             throw new ConstraintError(_loc25_);
  1393.          }
  1394.          param2 = Math.round(_loc33_ - _loc32_);
  1395.          if(!isNaN(_loc9_) && !isNaN(_loc10_))
  1396.          {
  1397.             _loc22_ = param2 - _loc9_ - _loc10_;
  1398.             if(_loc22_ < param3.minHeight)
  1399.             {
  1400.                _loc22_ = Number(param3.minHeight);
  1401.             }
  1402.          }
  1403.          else if(!isNaN(param3.percentHeight))
  1404.          {
  1405.             _loc22_ = param3.percentHeight / 100 * param2;
  1406.             _loc22_ = bound(_loc22_,param3.minHeight,param3.maxHeight);
  1407.             _loc27_ = true;
  1408.          }
  1409.          else
  1410.          {
  1411.             _loc22_ = Number(param3.getExplicitOrMeasuredHeight());
  1412.          }
  1413.          if(!isNaN(_loc8_))
  1414.          {
  1415.             if(_loc15_)
  1416.             {
  1417.                _loc23_ = Math.round((_loc35_ - _loc21_) / 2 + _loc8_ + _loc37_);
  1418.             }
  1419.             else
  1420.             {
  1421.                _loc23_ = Math.round((param1 - _loc21_) / 2 + _loc8_);
  1422.             }
  1423.          }
  1424.          else if(!isNaN(_loc6_))
  1425.          {
  1426.             if(_loc13_)
  1427.             {
  1428.                _loc23_ = _loc30_ + _loc6_;
  1429.             }
  1430.             else
  1431.             {
  1432.                _loc23_ = _loc6_;
  1433.             }
  1434.          }
  1435.          else if(!isNaN(_loc7_))
  1436.          {
  1437.             if(_loc14_)
  1438.             {
  1439.                _loc23_ = _loc31_ - _loc7_ - _loc21_;
  1440.             }
  1441.             else
  1442.             {
  1443.                _loc23_ = param1 - _loc7_ - _loc21_;
  1444.             }
  1445.          }
  1446.          if(!isNaN(_loc12_))
  1447.          {
  1448.             if(_loc19_)
  1449.             {
  1450.                _loc24_ = _loc38_ - param3.baselinePosition + _loc12_;
  1451.             }
  1452.             else
  1453.             {
  1454.                _loc24_ = _loc12_;
  1455.             }
  1456.          }
  1457.          if(!isNaN(_loc11_))
  1458.          {
  1459.             if(_loc18_)
  1460.             {
  1461.                _loc24_ = Math.round((_loc34_ - _loc22_) / 2 + _loc11_ + _loc36_);
  1462.             }
  1463.             else
  1464.             {
  1465.                _loc24_ = Math.round((param2 - _loc22_) / 2 + _loc11_);
  1466.             }
  1467.          }
  1468.          else if(!isNaN(_loc9_))
  1469.          {
  1470.             if(_loc16_)
  1471.             {
  1472.                _loc24_ = _loc32_ + _loc9_;
  1473.             }
  1474.             else
  1475.             {
  1476.                _loc24_ = _loc9_;
  1477.             }
  1478.          }
  1479.          else if(!isNaN(_loc10_))
  1480.          {
  1481.             if(_loc17_)
  1482.             {
  1483.                _loc24_ = _loc33_ - _loc10_ - _loc22_;
  1484.             }
  1485.             else
  1486.             {
  1487.                _loc24_ = param2 - _loc10_ - _loc22_;
  1488.             }
  1489.          }
  1490.          _loc23_ = isNaN(_loc23_) ? Number(param3.x) : _loc23_;
  1491.          _loc24_ = isNaN(_loc24_) ? Number(param3.y) : _loc24_;
  1492.          param3.move(_loc23_,_loc24_);
  1493.          if(_loc26_)
  1494.          {
  1495.             if(_loc23_ + _loc21_ > param1)
  1496.             {
  1497.                _loc21_ = Math.max(param1 - _loc23_,param3.minWidth);
  1498.             }
  1499.          }
  1500.          if(_loc27_)
  1501.          {
  1502.             if(_loc24_ + _loc22_ > param2)
  1503.             {
  1504.                _loc22_ = Math.max(param2 - _loc24_,param3.minHeight);
  1505.             }
  1506.          }
  1507.          if(!isNaN(_loc21_) && !isNaN(_loc22_))
  1508.          {
  1509.             param3.setActualSize(_loc21_,_loc22_);
  1510.          }
  1511.       }
  1512.       
  1513.       private function target_childAddHandler(param1:ChildExistenceChangedEvent) : void
  1514.       {
  1515.          DisplayObject(param1.relatedObject).addEventListener(MoveEvent.MOVE,child_moveHandler);
  1516.       }
  1517.    }
  1518. }
  1519.  
  1520. import mx.core.IUIComponent;
  1521.  
  1522. class LayoutConstraints
  1523. {
  1524.    public var baseline:*;
  1525.    
  1526.    public var left:*;
  1527.    
  1528.    public var bottom:*;
  1529.    
  1530.    public var top:*;
  1531.    
  1532.    public var horizontalCenter:*;
  1533.    
  1534.    public var verticalCenter:*;
  1535.    
  1536.    public var right:*;
  1537.    
  1538.    public function LayoutConstraints()
  1539.    {
  1540.       super();
  1541.    }
  1542. }
  1543.  
  1544. class ChildConstraintInfo
  1545. {
  1546.    public var baseline:Number;
  1547.    
  1548.    public var left:Number;
  1549.    
  1550.    public var baselineBoundary:String;
  1551.    
  1552.    public var leftBoundary:String;
  1553.    
  1554.    public var hcBoundary:String;
  1555.    
  1556.    public var top:Number;
  1557.    
  1558.    public var right:Number;
  1559.    
  1560.    public var topBoundary:String;
  1561.    
  1562.    public var rightBoundary:String;
  1563.    
  1564.    public var bottom:Number;
  1565.    
  1566.    public var vc:Number;
  1567.    
  1568.    public var bottomBoundary:String;
  1569.    
  1570.    public var vcBoundary:String;
  1571.    
  1572.    public var hc:Number;
  1573.    
  1574.    public function ChildConstraintInfo(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:String = null, param9:String = null, param10:String = null, param11:String = null, param12:String = null, param13:String = null, param14:String = null)
  1575.    {
  1576.       super();
  1577.       this.left = param1;
  1578.       this.right = param2;
  1579.       this.hc = param3;
  1580.       this.top = param4;
  1581.       this.bottom = param5;
  1582.       this.vc = param6;
  1583.       this.baseline = param7;
  1584.       this.leftBoundary = param8;
  1585.       this.rightBoundary = param9;
  1586.       this.hcBoundary = param10;
  1587.       this.topBoundary = param11;
  1588.       this.bottomBoundary = param12;
  1589.       this.vcBoundary = param13;
  1590.       this.baselineBoundary = param14;
  1591.    }
  1592. }
  1593.  
  1594. class ContentColumnChild
  1595. {
  1596.    public var rightCol:ConstraintColumn;
  1597.    
  1598.    public var hcCol:ConstraintColumn;
  1599.    
  1600.    public var left:Number;
  1601.    
  1602.    public var child:IUIComponent;
  1603.    
  1604.    public var rightOffset:Number;
  1605.    
  1606.    public var span:Number;
  1607.    
  1608.    public var hcOffset:Number;
  1609.    
  1610.    public var leftCol:ConstraintColumn;
  1611.    
  1612.    public var leftOffset:Number;
  1613.    
  1614.    public var hc:Number;
  1615.    
  1616.    public var right:Number;
  1617.    
  1618.    public function ContentColumnChild()
  1619.    {
  1620.       super();
  1621.    }
  1622. }
  1623.  
  1624. class ContentRowChild
  1625. {
  1626.    public var topRow:ConstraintRow;
  1627.    
  1628.    public var topOffset:Number;
  1629.    
  1630.    public var baseline:Number;
  1631.    
  1632.    public var baselineRow:ConstraintRow;
  1633.    
  1634.    public var span:Number;
  1635.    
  1636.    public var top:Number;
  1637.    
  1638.    public var vcOffset:Number;
  1639.    
  1640.    public var child:IUIComponent;
  1641.    
  1642.    public var bottomOffset:Number;
  1643.    
  1644.    public var bottom:Number;
  1645.    
  1646.    public var vc:Number;
  1647.    
  1648.    public var bottomRow:ConstraintRow;
  1649.    
  1650.    public var vcRow:ConstraintRow;
  1651.    
  1652.    public var baselineOffset:Number;
  1653.    
  1654.    public function ContentRowChild()
  1655.    {
  1656.       super();
  1657.    }
  1658. }
  1659.